Asymptotic Proportion of Hard Instances of the Halting Problem

Although the halting problem is undecidable, imperfect testers that fail on some instances are possible. Such instances are called hard for the tester. One variant of imperfect testers replies "I don't know" on hard instances, another variant fails to halt, and yet another replies incorrectly "yes" or "no". Also the halting problem has three variants: does a given program halt on the empty input, does a given program halt when given itself as its input, or does a given program halt on a given input. The failure rate of a tester for some size is the proportion of hard instances among all instances of that size. This publication investigates the behaviour of the failure rate as the size grows without limit. Earlier results are surveyed and new results are proven. Some of them use C++ on Linux as the computational model. It turns out that the behaviour is sensitive to the details of the programming language or computational model, but in many cases it is possible to prove that the proportion of hard instances does not vanish.Comment: 18 pages. The differences between this version and arXiv:1307.7066v1 are significant. They have been listed in the last paragraph of Section 1. Excluding layout, this arXiv version is essentially identical to the Acta Cybernetica versio

All Linear-Time Congruences for Familiar Operators

The detailed behaviour of a system is often represented as a labelled transition system (LTS) and the abstract behaviour as a stuttering-insensitive semantic congruence. Numerous congruences have been presented in the literature. On the other hand, there have not been many results proving the absence of more congruences. This publication fully analyses the linear-time (in a well-defined sense) region with respect to action prefix, hiding, relational renaming, and parallel composition. It contains 40 congruences. They are built from the alphabet, two kinds of traces, two kinds of divergence traces, five kinds of failures, and four kinds of infinite traces. In the case of finite LTSs, infinite traces lose their role and the number of congruences drops to 20. The publication concentrates on the hardest and most novel part of the result, that is, proving the absence of more congruences

Stop It, and Be Stubborn!

A system is AG EF terminating, if and only if from every reachable state, a terminal state is reachable. This publication argues that it is beneficial for both catching non-progress errors and stubborn set state space reduction to try to make verification models AG EF terminating. An incorrect mutual exclusion algorithm is used as an example. The error does not manifest itself, unless the first action of the customers is modelled differently from other actions. An appropriate method is to add an alternative first action that models the customer stopping for good. This method typically makes the model AG EF terminating. If the model is AG EF terminating, then the basic strong stubborn set method preserves safety and some progress properties without any additional condition for solving the ignoring problem. Furthermore, whether the model is AG EF terminating can be checked efficiently from the reduced state space

Roudan kehittymisen tilastollinen malli

vokKirjasto Aj-

A Simple Character String Proof of the "True but Unprovable" Version of G\"odel's First Incompleteness Theorem

A rather easy yet rigorous proof of a version of G\"odel's first incompleteness theorem is presented. The version is "each recursively enumerable theory of natural numbers with 0, 1, +, *, =, logical and, logical not, and the universal quantifier either proves a false sentence or fails to prove a true sentence". The proof proceeds by first showing a similar result on theories of finite character strings, and then transporting it to natural numbers, by using them to model strings and their concatenation. Proof systems are expressed via Turing machines that halt if and only if their input string is a theorem. This approach makes it possible to present all but one parts of the proof rather briefly with simple and straightforward constructions. The details require some care, but do not require significant background knowledge. The missing part is the widely known fact that Turing machines can perform complicated computational tasks.Comment: In Proceedings AFL 2014, arXiv:1405.527

Efficient Minimization of DFAs with Partial Transition Functions

Let PT-DFA mean a deterministic finite automaton whose transition relation is a partial function. We present an algorithm for minimizing a PT-DFA in $O(m \lg n)$ time and $O(m+n+\alpha)$ memory, where $n$ is the number of states, $m$ is the number of defined transitions, and $\alpha$ is the size of the alphabet. Time consumption does not depend on $\alpha$, because the $\alpha$ term arises from an array that is accessed at random and never initialized. It is not needed, if transitions are in a suitable order in the input. The algorithm uses two instances of an array-based data structure for maintaining a refinable partition. Its operations are all amortized constant time. One instance represents the classical blocks and the other a partition of transitions. Our measurements demonstrate the speed advantage of our algorithm on PT-DFAs over an $O(\alpha n \lg n)$ time, $O(\alpha n)$ memory algorithm

A Completeness Proof for A Regular Predicate Logic with Undefined Truth Value

We provide a sound and complete proof system for an extension of Kleene's ternary logic to predicates. The concept of theory is extended with, for each function symbol, a formula that specifies when the function is defined. The notion of "is defined" is extended to terms and formulas via a straightforward recursive algorithm. The "is defined" formulas are constructed so that they themselves are always defined. The completeness proof relies on the Henkin construction. For each formula, precisely one of the formula, its negation, and the negation of its "is defined" formula is true on the constructed model. Many other ternary logics in the literature can be reduced to ours. Partial functions are ubiquitous in computer science and even in (in)equation solving at schools. Our work was motivated by an attempt to explain, precisely in terms of logic, typical informal methods of reasoning in such applications.Comment: 39 pages, 1 figur

Automated Checking of Flexible Mathematical Reasoning in the Case of Systems of (In)Equations and the Absolute Value Operator

We present an approach and a tool for automatically providing feedback on solutions that involve complicated reasoning patterns. Currently the tool supports linear systems of equations and inequations that may also contain the absolute value operator and a restricted form of rational functions. This suffices for designing problems that are laborious to solve with standard mechanical procedures, but much easier using short-cuts that students may find by creative thinking. Earlier research has found that struggling with important mathematics promotes conceptual development. Our goal is to encourage students to such struggling. A crucial feature is to give them great freedom to choose the paths via which they solve problems, and at any time ask the tool to check the work done so far, no matter what path was chosen. This was implemented by adopting standard notation from mathematical logic, and developing some new logical notation. The tool has been used in a course on elementary universi ty-level mathematics. It has worked reliably, but there is not yet any statistics on the pedagogical merits. The tool is expected to also support quadratic (in)equations in the near future.peerReviewe